{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.0-beta1\n",
      "sys.version_info(major=3, minor=6, micro=5, releaselevel='final', serial=0)\n",
      "matplotlib 3.1.1\n",
      "numpy 1.16.4\n",
      "pandas 0.24.2\n",
      "sklearn 0.21.2\n",
      "tensorflow 2.0.0-beta1\n",
      "tensorflow.python.keras.api._v2.keras 2.2.4-tf\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import time\n",
    "\n",
    "from tensorflow import keras\n",
    "\n",
    "print(tf.__version__)\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, tf, keras:\n",
    "    print(module.__name__, module.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unicodedata\n",
    "import re\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "May I borrow this book?\n",
      "¿Puedo tomar prestado este libro?\n",
      "<start> may i borrow this book ? <end>\n",
      "b'<start> \\xc2\\xbf puedo tomar prestado este libro ? <end>'\n"
     ]
    }
   ],
   "source": [
    "def unicode_to_ascii(s):\n",
    "    return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn')\n",
    "\n",
    "en_sentence = u\"May I borrow this book?\"\n",
    "sp_sentence = u\"¿Puedo tomar prestado este libro?\"\n",
    "\n",
    "print(unicode_to_ascii(en_sentence))\n",
    "print(unicode_to_ascii(sp_sentence))\n",
    "\n",
    "def preprocess_sentence(w):\n",
    "    w = unicode_to_ascii(w.lower().strip())\n",
    "\n",
    "    # creating a space between a word and the punctuation following it\n",
    "    # eg: \"he is a boy.\" => \"he is a boy .\"\n",
    "    # Reference:- https://stackoverflow.com/questions/3645931/python-padding-punctuation-with-white-spaces-keeping-punctuation\n",
    "    w = re.sub(r\"([?.!,¿])\", r\" \\1 \", w)\n",
    "    w = re.sub(r'[\" \"]+', \" \", w)\n",
    "\n",
    "    # replacing everything with space except (a-z, A-Z, \".\", \"?\", \"!\", \",\")\n",
    "    w = re.sub(r\"[^a-zA-Z?.!,¿]+\", \" \", w)\n",
    "\n",
    "    w = w.rstrip().strip()\n",
    "\n",
    "    # adding a start and an end token to the sentence\n",
    "    # so that the model know when to start and stop predicting.\n",
    "    w = '<start> ' + w + ' <end>'\n",
    "    return w\n",
    "\n",
    "print(preprocess_sentence(en_sentence))\n",
    "print(preprocess_sentence(sp_sentence).encode('utf-8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<start> if you want to sound like a native speaker , you must be willing to practice saying the same sentence over and over in the same way that banjo players practice the same phrase over and over until they can play it correctly and at the desired tempo . <end>\n",
      "<start> si quieres sonar como un hablante nativo , debes estar dispuesto a practicar diciendo la misma frase una y otra vez de la misma manera en que un musico de banjo practica el mismo fraseo una y otra vez hasta que lo puedan tocar correctamente y en el tiempo esperado . <end>\n"
     ]
    }
   ],
   "source": [
    "data_path = './data_10_1/spa-eng/spa.txt'\n",
    "\n",
    "# 1. Remove the accents\n",
    "# 2. Clean the sentences\n",
    "# 3. Return word pairs in the format: [ENGLISH, SPANISH]\n",
    "def create_dataset(path, num_examples):\n",
    "    lines = open(path, encoding='UTF-8').read().strip().split('\\n')\n",
    "\n",
    "    word_pairs = [[preprocess_sentence(w) for w in l.split('\\t')]  for l in lines[:num_examples]]\n",
    "\n",
    "    return zip(*word_pairs)\n",
    "\n",
    "en, sp = create_dataset(data_path, None)\n",
    "print(en[-1])\n",
    "print(sp[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_length(tensor):\n",
    "    return max(len(t) for t in tensor)\n",
    "\n",
    "def tokenize(lang):\n",
    "    lang_tokenizer = tf.keras.preprocessing.text.Tokenizer(filters='')\n",
    "    lang_tokenizer.fit_on_texts(lang)\n",
    "    tensor = lang_tokenizer.texts_to_sequences(lang)\n",
    "    tensor = tf.keras.preprocessing.sequence.pad_sequences(tensor, padding='post')\n",
    "    return tensor, lang_tokenizer\n",
    "\n",
    "def load_dataset(path, num_examples=None):\n",
    "    # creating cleaned input, output pairs\n",
    "    targ_lang, inp_lang = create_dataset(path, num_examples)\n",
    "\n",
    "    input_tensor, inp_lang_tokenizer = tokenize(inp_lang)\n",
    "    target_tensor, targ_lang_tokenizer = tokenize(targ_lang)\n",
    "\n",
    "    return input_tensor, target_tensor, inp_lang_tokenizer, targ_lang_tokenizer\n",
    "\n",
    "# Try experimenting with the size of that dataset\n",
    "num_examples = 30000\n",
    "input_tensor, target_tensor, inp_lang, targ_lang = load_dataset(data_path, num_examples)\n",
    "\n",
    "# Calculate max_length of the target tensors\n",
    "max_length_targ, max_length_inp = max_length(target_tensor), max_length(input_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24000, 24000, 6000, 6000)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating training and validation sets using an 80-20 split\n",
    "input_tensor_train, input_tensor_val, target_tensor_train, target_tensor_val = train_test_split(input_tensor, target_tensor, test_size=0.2)\n",
    "\n",
    "# Show length\n",
    "len(input_tensor_train), len(target_tensor_train), len(input_tensor_val), len(target_tensor_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Language; index to word mapping\n",
      "1 ----> <start>\n",
      "6 ----> ¿\n",
      "311 ----> necesitas\n",
      "94 ----> algo\n",
      "14 ----> de\n",
      "19 ----> mi\n",
      "32 ----> ,\n",
      "4 ----> tom\n",
      "5 ----> ?\n",
      "2 ----> <end>\n",
      "\n",
      "Target Language; index to word mapping\n",
      "1 ----> <start>\n",
      "22 ----> do\n",
      "6 ----> you\n",
      "63 ----> need\n",
      "17 ----> me\n",
      "49 ----> ,\n",
      "5 ----> tom\n",
      "7 ----> ?\n",
      "2 ----> <end>\n"
     ]
    }
   ],
   "source": [
    "def convert(lang, tensor):\n",
    "    for t in tensor:\n",
    "        if t != 0:\n",
    "            print (\"%d ----> %s\" % (t, lang.index_word[t]))\n",
    "            \n",
    "print(\"Input Language; index to word mapping\")\n",
    "convert(inp_lang, input_tensor_train[0])\n",
    "print()\n",
    "print(\"Target Language; index to word mapping\")\n",
    "convert(targ_lang, target_tensor_train[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = len(input_tensor_train)\n",
    "BATCH_SIZE = 64\n",
    "steps_per_epoch = len(input_tensor_train)//BATCH_SIZE\n",
    "embedding_dim = 256\n",
    "units = 1024\n",
    "vocab_inp_size = len(inp_lang.word_index)+1\n",
    "vocab_tar_size = len(targ_lang.word_index)+1\n",
    "\n",
    "dataset = tf.data.Dataset.from_tensor_slices((input_tensor_train, target_tensor_train)).shuffle(BUFFER_SIZE)\n",
    "dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorShape([64, 16]), TensorShape([64, 11]))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_input_batch, example_target_batch = next(iter(dataset))\n",
    "example_input_batch.shape, example_target_batch.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoder output shape: (batch size, sequence length, units) (64, 16, 1024)\n",
      "Encoder Hidden state shape: (batch size, units) (64, 1024)\n"
     ]
    }
   ],
   "source": [
    "class Encoder(tf.keras.Model):\n",
    "    def __init__(self, vocab_size, embedding_dim, encoding_units, batch_size):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.batch_size = batch_size\n",
    "        self.encoding_units = encoding_units\n",
    "        self.embedding = keras.layers.Embedding(vocab_size, embedding_dim)\n",
    "        self.gru = keras.layers.GRU(self.encoding_units,\n",
    "                                    return_sequences=True,\n",
    "                                    return_state=True,\n",
    "                                    recurrent_initializer='glorot_uniform')\n",
    "\n",
    "    def call(self, x, hidden):\n",
    "        x = self.embedding(x)\n",
    "        output, state = self.gru(x, initial_state = hidden)\n",
    "        return output, state\n",
    "\n",
    "    def initialize_hidden_state(self):\n",
    "        return tf.zeros((self.batch_size, self.encoding_units))\n",
    "    \n",
    "encoder = Encoder(vocab_inp_size, embedding_dim, units, BATCH_SIZE)\n",
    "sample_hidden = encoder.initialize_hidden_state()\n",
    "sample_output, sample_hidden = encoder(example_input_batch, sample_hidden)\n",
    "\n",
    "print('Encoder output shape: (batch size, sequence length, units) {}'.format(sample_output.shape))\n",
    "print('Encoder Hidden state shape: (batch size, units) {}'.format(sample_hidden.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention result shape: (batch size, units) (64, 1024)\n",
      "Attention weights shape: (batch_size, sequence_length, 1) (64, 16, 1)\n"
     ]
    }
   ],
   "source": [
    "class BahdanauAttention(tf.keras.Model):\n",
    "    def __init__(self, units):\n",
    "        super(BahdanauAttention, self).__init__()\n",
    "        self.W1 = tf.keras.layers.Dense(units)\n",
    "        self.W2 = tf.keras.layers.Dense(units)\n",
    "        self.V = tf.keras.layers.Dense(1)\n",
    "\n",
    "    def call(self, query, values):\n",
    "        # hidden shape == (batch_size, hidden size)\n",
    "        # hidden_with_time_axis shape == (batch_size, 1, hidden size)\n",
    "        # we are doing this to perform addition to calculate the score\n",
    "        hidden_with_time_axis = tf.expand_dims(query, 1)\n",
    "\n",
    "        # score shape == (batch_size, max_length, 1)\n",
    "        # we get 1 at the last axis because we are applying score to self.V\n",
    "        # the shape of the tensor before applying self.V is (batch_size, max_length, units)\n",
    "        score = self.V(tf.nn.tanh(self.W1(values) + self.W2(hidden_with_time_axis)))\n",
    "\n",
    "        # attention_weights shape == (batch_size, max_length, 1)\n",
    "        attention_weights = tf.nn.softmax(score, axis=1)\n",
    "\n",
    "        # context_vector shape after sum == (batch_size, hidden_size)\n",
    "        context_vector = attention_weights * values\n",
    "        context_vector = tf.reduce_sum(context_vector, axis=1)\n",
    "\n",
    "        return context_vector, attention_weights\n",
    "    \n",
    "attention_layer = BahdanauAttention(10)\n",
    "attention_result, attention_weights = attention_layer(sample_hidden, sample_output)\n",
    "\n",
    "print(\"Attention result shape: (batch size, units) {}\".format(attention_result.shape))\n",
    "print(\"Attention weights shape: (batch_size, sequence_length, 1) {}\".format(attention_weights.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decoder output shape: (batch_size, vocab size) (64, 4935)\n"
     ]
    }
   ],
   "source": [
    "class Decoder(tf.keras.Model):\n",
    "    def __init__(self, vocab_size, embedding_dim, decoding_units, batch_size):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.batch_size = batch_size\n",
    "        self.decoding_units = decoding_units\n",
    "        self.embedding = keras.layers.Embedding(vocab_size, embedding_dim)\n",
    "        self.gru = keras.layers.GRU(self.decoding_units,\n",
    "                                    return_sequences=True,\n",
    "                                    return_state=True,\n",
    "                                    recurrent_initializer='glorot_uniform')\n",
    "        self.fc = keras.layers.Dense(vocab_size)\n",
    "\n",
    "        # used for attention\n",
    "        self.attention = BahdanauAttention(self.decoding_units)\n",
    "\n",
    "    def call(self, x, hidden, encoding_output):\n",
    "        # enc_output shape == (batch_size, max_length, hidden_size)\n",
    "        context_vector, attention_weights = self.attention(hidden, encoding_output)\n",
    "\n",
    "        # x shape after passing through embedding == (batch_size, 1, embedding_dim)\n",
    "        x = self.embedding(x)\n",
    "\n",
    "        # x shape after concatenation == (batch_size, 1, embedding_dim + hidden_size)\n",
    "        x = tf.concat([tf.expand_dims(context_vector, 1), x], axis=-1)\n",
    "\n",
    "        # passing the concatenated vector to the GRU\n",
    "        output, state = self.gru(x)\n",
    "\n",
    "        # output shape == (batch_size * 1, hidden_size)\n",
    "        output = tf.reshape(output, (-1, output.shape[2]))\n",
    "\n",
    "        # output shape == (batch_size, vocab)\n",
    "        x = self.fc(output)\n",
    "\n",
    "        return x, state, attention_weights\n",
    "\n",
    "decoder = Decoder(vocab_tar_size, embedding_dim, units, BATCH_SIZE)\n",
    "sample_decoder_output, _, _ = decoder(tf.random.uniform((64, 1)),\n",
    "                                      sample_hidden, sample_output)\n",
    "print ('Decoder output shape: (batch_size, vocab size) {}'.format(sample_decoder_output.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = keras.optimizers.Adam()\n",
    "loss_object = keras.losses.SparseCategoricalCrossentropy(from_logits=True, reduction='none')\n",
    "\n",
    "def loss_function(real, pred):\n",
    "    mask = tf.math.logical_not(tf.math.equal(real, 0))\n",
    "    loss_ = loss_object(real, pred)\n",
    "\n",
    "    mask = tf.cast(mask, dtype=loss_.dtype)\n",
    "    loss_ *= mask\n",
    "\n",
    "    return tf.reduce_mean(loss_)\n",
    "\n",
    "checkpoint_dir = './10-1_checkpoints'\n",
    "if not os.path.exists(checkpoint_dir):\n",
    "    os.mkdir(checkpoint_dir)\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
    "checkpoint = tf.train.Checkpoint(optimizer=optimizer,\n",
    "                                 encoder=encoder,\n",
    "                                 decoder=decoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def train_step(inp, targ, encoding_hidden):\n",
    "    loss = 0\n",
    "\n",
    "    with tf.GradientTape() as tape:\n",
    "        encoding_output, encoding_hidden = encoder(inp, encoding_hidden)\n",
    "\n",
    "        decoding_hidden = encoding_hidden\n",
    "\n",
    "        decoding_input = tf.expand_dims([targ_lang.word_index['<start>']] * BATCH_SIZE, 1)\n",
    "\n",
    "        # Teacher forcing - feeding the target as the next input\n",
    "        for t in range(1, targ.shape[1]):\n",
    "            # passing enc_output to the decoder\n",
    "            predictions, decoding_hidden, _ = decoder(decoding_input, decoding_hidden, encoding_output)\n",
    "\n",
    "            loss += loss_function(targ[:, t], predictions)\n",
    "\n",
    "            # using teacher forcing\n",
    "            decoding_input = tf.expand_dims(targ[:, t], 1)\n",
    "\n",
    "    batch_loss = (loss / int(targ.shape[1]))\n",
    "    variables = encoder.trainable_variables + decoder.trainable_variables\n",
    "    gradients = tape.gradient(loss, variables)\n",
    "    optimizer.apply_gradients(zip(gradients, variables))\n",
    "    return batch_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 Batch 0 Loss 4.5664\n",
      "Epoch 1 Batch 100 Loss 2.3050\n",
      "Epoch 1 Batch 200 Loss 1.7303\n",
      "Epoch 1 Batch 300 Loss 1.5328\n",
      "Epoch 1 Loss 2.0133\n",
      "Time taken for 1 epoch 192.02873945236206 sec\n",
      "\n",
      "Epoch 2 Batch 0 Loss 1.5067\n",
      "Epoch 2 Batch 100 Loss 1.4738\n",
      "Epoch 2 Batch 200 Loss 1.2702\n",
      "Epoch 2 Batch 300 Loss 1.0948\n",
      "Epoch 2 Loss 1.3962\n",
      "Time taken for 1 epoch 169.28043389320374 sec\n",
      "\n",
      "Epoch 3 Batch 0 Loss 1.0985\n",
      "Epoch 3 Batch 100 Loss 1.1094\n",
      "Epoch 3 Batch 200 Loss 0.8822\n",
      "Epoch 3 Batch 300 Loss 0.7151\n",
      "Epoch 3 Loss 1.0286\n",
      "Time taken for 1 epoch 168.75251841545105 sec\n",
      "\n",
      "Epoch 4 Batch 0 Loss 0.7692\n",
      "Epoch 4 Batch 100 Loss 0.8170\n",
      "Epoch 4 Batch 200 Loss 0.6078\n",
      "Epoch 4 Batch 300 Loss 0.4636\n",
      "Epoch 4 Loss 0.7140\n",
      "Time taken for 1 epoch 169.04330253601074 sec\n",
      "\n",
      "Epoch 5 Batch 0 Loss 0.5110\n",
      "Epoch 5 Batch 100 Loss 0.5733\n",
      "Epoch 5 Batch 200 Loss 0.4331\n",
      "Epoch 5 Batch 300 Loss 0.2875\n",
      "Epoch 5 Loss 0.4824\n",
      "Time taken for 1 epoch 168.50223565101624 sec\n",
      "\n",
      "Epoch 6 Batch 0 Loss 0.3328\n",
      "Epoch 6 Batch 100 Loss 0.3765\n",
      "Epoch 6 Batch 200 Loss 0.3134\n",
      "Epoch 6 Batch 300 Loss 0.1931\n",
      "Epoch 6 Loss 0.3275\n",
      "Time taken for 1 epoch 167.89863872528076 sec\n",
      "\n",
      "Epoch 7 Batch 0 Loss 0.2408\n",
      "Epoch 7 Batch 100 Loss 0.2852\n",
      "Epoch 7 Batch 200 Loss 0.2240\n",
      "Epoch 7 Batch 300 Loss 0.1333\n",
      "Epoch 7 Loss 0.2285\n",
      "Time taken for 1 epoch 169.23886895179749 sec\n",
      "\n",
      "Epoch 8 Batch 0 Loss 0.1680\n",
      "Epoch 8 Batch 100 Loss 0.1789\n",
      "Epoch 8 Batch 200 Loss 0.1661\n",
      "Epoch 8 Batch 300 Loss 0.1008\n",
      "Epoch 8 Loss 0.1645\n",
      "Time taken for 1 epoch 167.00152730941772 sec\n",
      "\n",
      "Epoch 9 Batch 0 Loss 0.1228\n",
      "Epoch 9 Batch 100 Loss 0.1339\n",
      "Epoch 9 Batch 200 Loss 0.1539\n",
      "Epoch 9 Batch 300 Loss 0.0833\n",
      "Epoch 9 Loss 0.1246\n",
      "Time taken for 1 epoch 166.93335962295532 sec\n",
      "\n",
      "Epoch 10 Batch 0 Loss 0.1059\n",
      "Epoch 10 Batch 100 Loss 0.0950\n",
      "Epoch 10 Batch 200 Loss 0.1322\n",
      "Epoch 10 Batch 300 Loss 0.0738\n",
      "Epoch 10 Loss 0.0966\n",
      "Time taken for 1 epoch 167.8072121143341 sec\n",
      "\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 10\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    start = time.time()\n",
    "\n",
    "    encoding_hidden = encoder.initialize_hidden_state()\n",
    "    total_loss = 0\n",
    "\n",
    "    for (batch, (inp, targ)) in enumerate(dataset.take(steps_per_epoch)):\n",
    "        batch_loss = train_step(inp, targ, encoding_hidden)\n",
    "        total_loss += batch_loss\n",
    "\n",
    "        if batch % 100 == 0:\n",
    "            print('Epoch {} Batch {} Loss {:.4f}'.format(epoch + 1, batch, batch_loss.numpy()))\n",
    "    # saving (checkpoint) the model every 2 epochs\n",
    "    if (epoch + 1) % 2 == 0:\n",
    "        checkpoint.save(file_prefix = checkpoint_prefix)\n",
    "\n",
    "    print('Epoch {} Loss {:.4f}'.format(epoch + 1, total_loss / steps_per_epoch))\n",
    "    print('Time taken for 1 epoch {} sec\\n'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f0cd91e1fd0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def evaluate(sentence):\n",
    "    attention_plot = np.zeros((max_length_targ, max_length_inp))\n",
    "    sentence = preprocess_sentence(sentence)\n",
    "\n",
    "    inputs = [inp_lang.word_index[i] for i in sentence.split(' ')]\n",
    "    inputs = keras.preprocessing.sequence.pad_sequences([inputs], maxlen=max_length_inp, padding='post')\n",
    "    inputs = tf.convert_to_tensor(inputs)\n",
    "\n",
    "    result = ''\n",
    "\n",
    "    hidden = [tf.zeros((1, units))]\n",
    "    encoding_out, encoding_hidden = encoder(inputs, hidden)\n",
    "\n",
    "    decoding_hidden = encoding_hidden\n",
    "    decoding_input = tf.expand_dims([targ_lang.word_index['<start>']], 0)\n",
    "\n",
    "    for t in range(max_length_targ):\n",
    "        predictions, decoding_hidden, attention_weights = decoder(\n",
    "            decoding_input, decoding_hidden, encoding_out)\n",
    "\n",
    "        # storing the attention weights to plot later on\n",
    "        attention_weights = tf.reshape(attention_weights, (-1, ))\n",
    "        attention_plot[t] = attention_weights.numpy()\n",
    "\n",
    "        predicted_id = tf.argmax(predictions[0]).numpy()\n",
    "\n",
    "        result += targ_lang.index_word[predicted_id] + ' '\n",
    "\n",
    "        if targ_lang.index_word[predicted_id] == '<end>':\n",
    "            return result, sentence, attention_plot\n",
    "\n",
    "        # the predicted ID is fed back into the model\n",
    "        decoding_input = tf.expand_dims([predicted_id], 0)\n",
    "\n",
    "    return result, sentence, attention_plot\n",
    "\n",
    "# function for plotting the attention weights\n",
    "def plot_attention(attention, sentence, predicted_sentence):\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    ax = fig.add_subplot(1, 1, 1)\n",
    "    ax.matshow(attention, cmap='viridis')\n",
    "\n",
    "    fontdict = {'fontsize': 14}\n",
    "\n",
    "    ax.set_xticklabels([''] + sentence, fontdict=fontdict, rotation=90)\n",
    "    ax.set_yticklabels([''] + predicted_sentence, fontdict=fontdict)\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "def translate(sentence):\n",
    "    result, sentence, attention_plot = evaluate(sentence)\n",
    "\n",
    "    print('Input: %s' % (sentence))\n",
    "    print('Predicted translation: {}'.format(result))\n",
    "\n",
    "    attention_plot = attention_plot[:len(result.split(' ')), :len(sentence.split(' '))]\n",
    "    plot_attention(attention_plot, sentence.split(' '), result.split(' '))\n",
    "    \n",
    "\n",
    "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> hace mucho frio aqui . <end>\n",
      "Predicted translation: it s very cold here . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'hace mucho frio aqui.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> esta es mi vida . <end>\n",
      "Predicted translation: this is my life . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'esta es mi vida.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> ¿ todavia estan en casa ? <end>\n",
      "Predicted translation: are you still at home ? <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'¿todavia estan en casa?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: <start> trata de averiguarlo . <end>\n",
      "Predicted translation: try to laughed . <end> \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "translate(u'trata de averiguarlo.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
